home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / machserver / 1.098 / net / netCode.c < prev    next >
C/C++ Source or Header  |  1991-03-16  |  28KB  |  1,043 lines
  1. /* 
  2.  * netCode.c --
  3.  *
  4.  *    Various routines for initialzation, input and output.
  5.  *
  6.  *
  7.  * Copyright 1987 Regents of the University of California
  8.  * Permission to use, copy, modify, and distribute this
  9.  * software and its documentation for any purpose and without
  10.  * fee is hereby granted, provided that the above copyright
  11.  * notice appear in all copies.  The University of California
  12.  * makes no representations about the suitability of this
  13.  * software for any purpose.  It is provided "as is" without
  14.  * express or implied warranty.
  15.  */
  16.  
  17. #ifndef lint
  18. static char rcsid[] = "$Header: /sprite/src/kernel/net/RCS/netCode.c,v 9.7 91/03/15 15:47:07 jhh Exp Locker: mgbaker $ SPRITE (Berkeley)";
  19. #endif
  20.  
  21. #include <sprite.h>
  22. #include <list.h>
  23. #include <net.h>
  24. #include <netInt.h>
  25. #include <devNet.h>
  26. #include <sync.h>
  27. #include <dbg.h>
  28. #include <machMon.h>
  29. #include <netInet.h>
  30.  
  31. /*
  32.  * Network configuration table defined by machine dependent code.
  33.  */
  34. extern Net_Interface    netConfigInterfaces[];
  35. extern int        netNumConfigInterfaces;
  36. Net_Interface        *netInterfaces[NET_MAX_INTERFACES];
  37. int            netNumInterfaces;
  38.  
  39. Net_Address         netZeroAddress;
  40. int            net_NetworkHeaderSize[NET_NUM_NETWORK_TYPES];
  41.  
  42. #define    INC_BYTES_SENT(gatherPtr, gatherLength) { \
  43.     register    Net_ScatterGather    *gathPtr; \
  44.     int                    i; \
  45.     net_EtherStats.bytesSent += sizeof(Net_EtherHdr); \
  46.     for (i = gatherLength, gathPtr = gatherPtr; i > 0; i--, gathPtr++) { \
  47.         net_EtherStats.bytesSent += gathPtr->length; \
  48.     } \
  49.     }
  50. /*
  51.  * Macro to swap the fragOffset field.
  52.  */
  53. #define SWAP_FRAG_OFFSET_HOST_TO_NET(ptr) { \
  54.     unsigned short    *shortPtr; \
  55.     shortPtr = ((unsigned short *)&ptr->ident) + 1; \
  56.     *shortPtr = Net_HostToNetShort(*shortPtr); \
  57. } 
  58.  
  59. #define SWAP_FRAG_OFFSET_NET_TO_HOST(ptr) { \
  60.     unsigned short    *shortPtr; \
  61.     shortPtr = ((unsigned short *)&ptr->ident) + 1; \
  62.     *shortPtr = Net_NetToHostShort(*shortPtr); \
  63. } 
  64.  
  65. int netDebug = FALSE;
  66. Boolean    ultra = FALSE;
  67.  
  68. static void NetAddStats _ARGS_((Net_Stats *aPtr, Net_Stats *bPtr, 
  69.             Net_Stats *sumPtr));
  70. static void EnterDebugger _ARGS_((Net_Interface *interPtr, Address packetPtr,
  71.                 int packetLength));
  72.  
  73. /*
  74.  *----------------------------------------------------------------------
  75.  *
  76.  * Net_Init --
  77.  *
  78.  *    Initialize the network module data structures.
  79.  *
  80.  * Results:
  81.  *    None.
  82.  *
  83.  * Side effects:
  84.  *    None.
  85.  *
  86.  *----------------------------------------------------------------------
  87.  */
  88.  
  89. void
  90. Net_Init()
  91. {
  92.     register int i;
  93.     char buffer[100];
  94.     ReturnStatus status;
  95.     int        counter[NET_NUM_NETWORK_TYPES];
  96.     Net_Interface    *interPtr;
  97.  
  98.     NetEtherInit();
  99.  
  100.     for (i = 0; i < NET_NUM_NETWORK_TYPES; i++) {
  101.     counter[i] = 0;
  102.     }
  103.  
  104.     /*
  105.      * Determine the number and kind of network interfaces by calling
  106.      * each network interface initialization procedure.
  107.      */
  108.     bzero((char *) &netZeroAddress, sizeof(Net_Address));
  109.     netNumInterfaces = 0;
  110.     for (i = 0 ; i<netNumConfigInterfaces ; i++) {
  111.     netConfigInterfaces[i].flags = 0;
  112.     status = (netConfigInterfaces[i].init)(&(netConfigInterfaces[i]));
  113.     if (status == SUCCESS) {
  114.         netInterfaces[netNumInterfaces] = &netConfigInterfaces[i];
  115.         interPtr = netInterfaces[netNumInterfaces];
  116.         netNumInterfaces++;
  117.         interPtr->packetProc = NILPROC;
  118.         interPtr->devNetData = (ClientData) NIL;
  119.         interPtr->number = counter[interPtr->netType];
  120.         counter[interPtr->netType]++;
  121.         sprintf(buffer, "NetOutputMutex:%d", i);
  122.         Sync_SemInitDynamic(&interPtr->syncOutputMutex, 
  123.         buffer);
  124.         sprintf(buffer, "NetMutex:%d", i);
  125.         Sync_SemInitDynamic(&interPtr->mutex, buffer);
  126.     } 
  127.     }
  128.     net_NetworkHeaderSize[NET_NETWORK_ETHER] = sizeof(Net_EtherHdr);
  129.     net_NetworkHeaderSize[NET_NETWORK_ULTRA] = sizeof(Net_UltraHeader);
  130.     Net_ArpInit();
  131.     return;
  132. }
  133.  
  134. /*
  135.  *----------------------------------------------------------------------
  136.  *
  137.  * Net_Bin --
  138.  *
  139.  *    Bin various memory sizes allocated by the net module.
  140.  *
  141.  * Results:
  142.  *    None.
  143.  *
  144.  * Side effects:
  145.  *    Calls Mem_Bin to optimize memory allocation.
  146.  *
  147.  *----------------------------------------------------------------------
  148.  */
  149.  
  150. void
  151. Net_Bin()
  152. {
  153.     register int inter;
  154.     for (inter = 0 ; inter < netNumInterfaces ; inter++) {
  155.     Mem_Bin(netInterfaces[inter]->maxBytes);
  156.     }
  157.     return;
  158. }
  159.  
  160. /*
  161.  *----------------------------------------------------------------------
  162.  *
  163.  * Net_GatherCopy --
  164.  *
  165.  *    Copy all of the data pointed to by the scatter/gather array into
  166.  *    the destination.
  167.  *
  168.  * Results:
  169.  *    None.
  170.  *
  171.  * Side effects:
  172.  *    None.
  173.  *
  174.  *----------------------------------------------------------------------
  175.  */
  176.  
  177. void
  178. Net_GatherCopy(scatterGatherPtr, scatterGatherLength, destAddr)
  179.     register    Net_ScatterGather *scatterGatherPtr;
  180.     int                    scatterGatherLength;
  181.     register    Address          destAddr;
  182. {
  183.     int i;
  184.     int soFar = 0;
  185.  
  186.     for (i = 0; i < scatterGatherLength; i++, scatterGatherPtr++) {
  187.     if (scatterGatherPtr->length == 0) {
  188.         continue;
  189.     }
  190.  
  191.     bcopy((Address) scatterGatherPtr->bufAddr, 
  192.          (Address) &(destAddr[soFar]), 
  193.          scatterGatherPtr->length);
  194.     soFar += scatterGatherPtr->length;
  195.     }
  196.     return;
  197. }
  198.  
  199.  
  200.  
  201. /*
  202.  *----------------------------------------------------------------------
  203.  *
  204.  * Net_Reset --
  205.  *
  206.  *    Reset the network interface.
  207.  *
  208.  * Results:
  209.  *    None.
  210.  *
  211.  * Side effects:
  212.  *    Reinitializes the network controller..
  213.  *
  214.  *----------------------------------------------------------------------
  215.  */
  216. void
  217. Net_Reset(interPtr)
  218.     Net_Interface    *interPtr;
  219. {
  220.     interPtr->reset(interPtr);
  221. }
  222.  
  223.  
  224. /*
  225.  *----------------------------------------------------------------------
  226.  *
  227.  * Net_Output --
  228.  *
  229.  *    Send a packet to a host identified by a Sprite Host ID.
  230.  *
  231.  * Results:
  232.  *    SUCCESS     - the operation was successful.
  233.  *    FAILURE        - there was no route to the host or 
  234.  *              the Sprite host ID was bad or 
  235.  *              an unknown route type was found.
  236.  *
  237.  * Side effects:
  238.  *    Sends the packet.
  239.  *    If no route has been established to the SpriteID then the
  240.  *    Address Resolution Protocol (ARP) is invoked to find the
  241.  *    physical address corresponding to the SpriteID.
  242.  *
  243.  *----------------------------------------------------------------------
  244.  */
  245.  
  246. ReturnStatus
  247. Net_Output(spriteID, gatherPtr, gatherLength, mutexPtr, routePtr)
  248.     int spriteID;            /* Host to which to send the packet */
  249.     Net_ScatterGather *gatherPtr;    /* Specifies buffers containing the
  250.                      * pieces of the packet The first
  251.                      * element of gatherPtr is assumed to 
  252.                      * be a buffer large enought to 
  253.                      * format any protocol headers
  254.                      * we need. */
  255.     int gatherLength;            /* Number of elements in gatherPtr[] */
  256.     Sync_Semaphore *mutexPtr;        /* Mutex that is released during the
  257.                      * ARP transaction (if needed).  This
  258.                      * doesn't mess up the caller because
  259.                      * its packet isn't output until
  260.                      * the ARP completes anyway */
  261.     Net_Route    *routePtr;        /* If non-NIL then used as the route
  262.                      * to send the packet. */
  263. {
  264.     Net_Interface    *interPtr;
  265.     Boolean        ourRoute = FALSE;
  266.     ReturnStatus    status;
  267.  
  268.     if (spriteID < 0 || spriteID >= NET_NUM_SPRITE_HOSTS) {
  269.     return(NET_UNREACHABLE_NET);
  270.     }
  271.  
  272.     /*
  273.      * Check for a route to the indicated host.  Use ARP to find it if needed.
  274.      */
  275.     if (routePtr == (Net_Route *) NIL) {
  276.     ourRoute = TRUE;
  277.     routePtr = Net_IDToRoute(spriteID, 0, TRUE, mutexPtr, 0);
  278.     if (routePtr == (Net_Route *)NIL) {
  279.         return(NET_UNREACHABLE_NET);
  280.     }
  281.     }
  282.     interPtr = routePtr->interPtr;
  283.     switch(routePtr->protocol) {
  284.     case NET_PROTO_RAW : {
  285.         /*
  286.          * The first gather buffer contains the protocol header for
  287.          * which we have none for the ethernet.
  288.          */
  289.         gatherPtr->length = 0;     
  290.         gatherPtr->done = FALSE;
  291.         gatherPtr->mutexPtr = mutexPtr;
  292.         status = (interPtr->output) (interPtr, 
  293.             routePtr->headerPtr[NET_PROTO_RAW], 
  294.             gatherPtr, gatherLength, TRUE, &status);
  295.         if (status == SUCCESS) {
  296.             while (!gatherPtr->done && 
  297.             mutexPtr != (Sync_Semaphore *)NIL) {
  298.             (void) Sync_SlowMasterWait((unsigned int)mutexPtr, 
  299.                 mutexPtr, 0);
  300.             }
  301.         }
  302.         break;
  303.         }
  304.     case NET_PROTO_INET: {
  305.         /*
  306.          * For the INET routes we must fill in the ipHeader in the 
  307.          * first buffer of the gather array. 
  308.          */
  309.         register Net_IPHeader        *ipHeaderPtr;
  310.         register unsigned int length;
  311.         register Net_ScatterGather    *gathPtr;
  312.         register int     i; 
  313.  
  314.         /*
  315.          * Compute the length of the gather vector. 
  316.          */
  317.         length = sizeof(Net_IPHeader);
  318.         gathPtr = gatherPtr + 1;
  319.         for (i = 1; i < gatherLength;  i++, gathPtr++){
  320.             length += gathPtr->length; 
  321.         }
  322.  
  323.  
  324.         /*
  325.          * Fill the  ipHeader into the first element of the 
  326.          * scatter/gather from the template stored in the route
  327.          * data.
  328.          */
  329.         gatherPtr->length = sizeof(Net_IPHeader);
  330.         ipHeaderPtr = (Net_IPHeader *) gatherPtr->bufAddr;
  331.         gatherPtr->done = FALSE;
  332.         gatherPtr->mutexPtr = mutexPtr;
  333.  
  334.         *ipHeaderPtr = *(Net_IPHeader *) 
  335.                     routePtr->headerPtr[NET_PROTO_INET];
  336.         /*
  337.          * Update length and checksum. The template 
  338.          * ipHeaderPtr->checksum should contain the 16 bit sum of 
  339.          * the IP header with totalLen set to zero. We add the
  340.          * new total length and convert into one-complement.
  341.          * See Net_InetChecksum().
  342.          */
  343.         length = Net_HostToNetShort(length);
  344.         ipHeaderPtr->totalLen = length;
  345.  
  346.         length = ipHeaderPtr->checksum + length;
  347.         ipHeaderPtr->checksum = ~(length + (length >> 16));
  348.  
  349.         status = (interPtr->output)(interPtr, 
  350.             routePtr->headerPtr[NET_PROTO_RAW], gatherPtr, 
  351.             gatherLength, FALSE, &status);
  352.         if (status == SUCCESS) {
  353.             while (!gatherPtr->done && 
  354.             mutexPtr != (Sync_Semaphore *)NIL) {
  355.             (void) Sync_SlowMasterWait((unsigned int)mutexPtr, 
  356.                     mutexPtr, 0);
  357.             }
  358.         }
  359.         break;
  360.         }
  361.     default:
  362.         printf("Warning: Net_Output: unsupported route protocol: %x\n", 
  363.             routePtr->protocol);
  364.         panic(NIL);
  365.         status = FAILURE;
  366.     }
  367.     if (ourRoute) {
  368.     Net_ReleaseRoute(routePtr);
  369.     }
  370.     return status;
  371. }
  372.  
  373.  
  374.  
  375. /*
  376.  *----------------------------------------------------------------------
  377.  *
  378.  * Net_RawOutput --
  379.  *
  380.  *    Send a packet directly onto the network.
  381.  *
  382.  * Results:
  383.  *    SUCCESS if the packet made it as far as the network interface,
  384.  *    a failure code otherwise.  SUCCESS does not imply that the
  385.  *    packet was actually sent because the interface could have
  386.  *    rejected it.
  387.  *
  388.  * Side effects:
  389.  *    None.
  390.  *
  391.  *----------------------------------------------------------------------
  392.  */
  393.  
  394. ReturnStatus
  395. Net_RawOutput(interPtr, headerPtr, gatherPtr, gatherLength)
  396.     Net_Interface    *interPtr;    /* The network interface. */
  397.     Address        headerPtr;    /* Packet header. */
  398.     Net_ScatterGather    *gatherPtr;    /* Specifies buffers containing the
  399.                      * pieces of the packet */
  400.     int         gatherLength;    /* Number of elements in gatherPtr[] */
  401. {
  402.     return (interPtr->output)(interPtr, headerPtr, gatherPtr, gatherLength, 
  403.         FALSE, (ReturnStatus *) NIL);
  404. }
  405.  
  406.  
  407. /*
  408.  *----------------------------------------------------------------------
  409.  *
  410.  * Net_RecvPoll --
  411.  *
  412.  *    See if a packet has come in.  If one has come in then it is assumed
  413.  *    that the packet processing routine will get called.  Thus this routine
  414.  *    does not return any value; it is up to the packet processing routine
  415.  *    to set some global state.  This is intended to be used by the
  416.  *    debugger.
  417.  *
  418.  * Results:
  419.  *    None.
  420.  *
  421.  * Side effects:
  422.  *    None.
  423.  *
  424.  *----------------------------------------------------------------------
  425.  */
  426.  
  427. void
  428. Net_RecvPoll(interPtr)
  429.     Net_Interface    *interPtr;    /* Network interface. */
  430. {
  431.     if (netDebug) {
  432.     printf("Net_RecvPoll\n");
  433.     }
  434.     (interPtr->intr)(interPtr, TRUE);
  435. }
  436.  
  437.  
  438. /*
  439.  *----------------------------------------------------------------------
  440.  *
  441.  * Net_RawOutputSync --
  442.  *
  443.  *     Send a packet on the network. Does not return until the packet
  444.  *    is actually sent.
  445.  *
  446.  * Results:
  447.  *    SUCCESS if the packet was sent correctly, otherwise a standard
  448.  *    Sprite return status.
  449.  *
  450.  * Side effects:
  451.  *    None.
  452.  *
  453.  *----------------------------------------------------------------------
  454.  */
  455. ReturnStatus
  456. Net_RawOutputSync(interPtr, headerPtr, gatherPtr, gatherLength)
  457.     Net_Interface    *interPtr;    /* Network interface. */
  458.     Address        headerPtr;    /* Packet header. */
  459.     Net_ScatterGather     *gatherPtr;    /* Specifies buffers containing the
  460.                      * pieces of the packet */
  461.     int         gatherLength;    /* Number of elements in gatherPtr[] */
  462. {
  463.     ReturnStatus    status;
  464.  
  465.     gatherPtr->mutexPtr = &(interPtr->syncOutputMutex);
  466.     gatherPtr->done = FALSE;
  467.  
  468.     MASTER_LOCK(&(interPtr->syncOutputMutex));
  469.  
  470.     status = (interPtr->output)(interPtr, headerPtr, gatherPtr, gatherLength, 
  471.     FALSE, &status);
  472.     if (status == SUCCESS) {
  473.     while (!gatherPtr->done) {
  474.         (void) Sync_SlowMasterWait(
  475.             (unsigned int)&(interPtr->syncOutputMutex), 
  476.             &(interPtr->syncOutputMutex), FALSE);
  477.     }
  478.     }
  479.     MASTER_UNLOCK(&(interPtr->syncOutputMutex));
  480.     return status;
  481. }
  482.  
  483. /*
  484.  *----------------------------------------------------------------------
  485.  *
  486.  * NetOutputWakeup --
  487.  *
  488.  *    Called to notify a waiter that a packet has been sent.  This is
  489.  *    hacked up now, as the argument is really a mutexPtr which
  490.  *    has been used as a raw event to wait on.  We have to use
  491.  *    the raw SlowBroadcast procedure because of this.
  492.  *
  493.  * Results:
  494.  *    None.
  495.  *
  496.  * Side effects:
  497.  *    None.
  498.  *
  499.  *----------------------------------------------------------------------
  500.  */
  501.  
  502. void
  503. NetOutputWakeup(mutexPtr)
  504.     Sync_Semaphore    *mutexPtr;    /* Mutex from scatter/gather struct */
  505. {
  506.     int waiting;
  507.  
  508.     /*
  509.      * FIX THIS.
  510.      */
  511.     if (dbg_UsingNetwork) {
  512.     return;
  513.     }
  514.  
  515. #if (MACH_MAX_NUM_PROCESSORS == 1) /* uniprocessor implementation */
  516.     (void) Sync_SlowBroadcast((unsigned int)mutexPtr, &waiting);
  517. #else     /* Mutiprocessor implementation */
  518.    /*
  519.     * Because the packet sent interrupt may come in before Net_Output
  520.     * has a chance to MasterWait and after Net_Output has checked the
  521.     * gatherPtr->done flag, the code should syncronize with the caller
  522.     * by obtaining the master lock.
  523.     */
  524.     MASTER_LOCK(mutexPtr);
  525.     (void) Sync_SlowBroadcast((unsigned int) mutexPtr, &waiting);    
  526.     MASTER_UNLOCK(mutexPtr);
  527. #endif
  528.     return;
  529. }
  530.  
  531.  
  532. /*
  533.  *----------------------------------------------------------------------
  534.  *
  535.  * Net_Intr --
  536.  *
  537.  *    The interrupt routine which is called when the ethernet chip 
  538.  *    interrupts the processor.  All this routine does is to branch
  539.  *    to the interrupt handler for the type of ethernet device
  540.  *    present on the machine.  The device driver, in turn, eventually
  541.  *    calls Net_Input to pass the packet to the correct protocol handler.
  542.  *
  543.  * Results:
  544.  *    None.
  545.  *
  546.  * Side effects:
  547.  *    None.
  548.  *
  549.  *----------------------------------------------------------------------
  550.  */
  551.  
  552. int
  553. Net_Intr(interPtr)
  554.     Net_Interface    *interPtr;    /* Network interface. */
  555. {
  556.     if (netDebug) {
  557.     printf("Received an interrupt on interface %s\n", interPtr->name);
  558.     }
  559.     (interPtr->intr)(interPtr, FALSE);
  560.     return 1;
  561. }
  562.  
  563. /*
  564.  *----------------------------------------------------------------------
  565.  *
  566.  * Net_Input --
  567.  *
  568.  *    A stub called by device drivers to pass off packets to protocols.
  569.  *    This could be a macro.
  570.  *
  571.  *    The packet handler called must copy the packet to private buffers.
  572.  *
  573.  *    TODO:
  574.  *        This routine, and the ones it calls, should not assume
  575.  *        that there is a packet header at the start of the
  576.  *        packet.  The header should be passed separately.
  577.  *
  578.  * Results:
  579.  *    None.
  580.  *
  581.  * Side effects:
  582.  *    None.  
  583.  *
  584.  *----------------------------------------------------------------------
  585.  */
  586.  
  587. void
  588. Net_Input(interPtr, packetPtr, packetLength)
  589.     Net_Interface *interPtr;    /* Network interface. */
  590.     Address packetPtr;        /* The packet. */
  591.     int packetLength;        /* The length of the packet. */
  592. {
  593.     int        headerSize;
  594.     int        packetType = NET_PACKET_UNKNOWN;
  595.     Boolean    ultra = FALSE;
  596.  
  597. #if 0
  598.     printf("in Net_Input\n");
  599.     printf("Net_Input(0x%x, 0x%x, 0x%x)\n", interPtr, packetPtr, packetLength);
  600.     printf("netType = %08x\n", interPtr->netType);
  601. #endif
  602.  
  603.     if (netDebug) {
  604.     printf("Net_Input(0x%x, 0x%x, 0x%x) netType = %08x\n",
  605.         interPtr, packetPtr, packetLength, interPtr->netType);
  606.     }
  607.     switch(interPtr->netType) {
  608.     case NET_NETWORK_ETHER : {
  609.         Net_EtherHdr *etherHdrPtr;
  610.         int        type;
  611.         etherHdrPtr = (Net_EtherHdr *)packetPtr;
  612.         type = Net_NetToHostShort((unsigned short)
  613.             NET_ETHER_HDR_TYPE(*etherHdrPtr));
  614.         switch(type) {
  615.         case NET_ETHER_SPRITE:
  616.             packetType = NET_PACKET_SPRITE;
  617.             break;
  618.         case NET_ETHER_ARP:
  619.             packetType = NET_PACKET_ARP;
  620.             break;
  621.         case NET_ETHER_REVARP:
  622.             packetType = NET_PACKET_RARP;
  623.             break;
  624.         case NET_ETHER_SPRITE_DEBUG:
  625.             packetType = NET_PACKET_DEBUG;
  626.             break;
  627.         case NET_ETHER_IP:
  628.             packetType = NET_PACKET_IP;
  629.             break;
  630.         default:
  631.             packetType = NET_PACKET_UNKNOWN;
  632.             break;
  633.         }
  634.         ultra = FALSE;
  635.         break;
  636.     }
  637.     case NET_NETWORK_ULTRA: {
  638.         Net_UltraHeader    *ultraHdrPtr;
  639.         ultraHdrPtr = (Net_UltraHeader *) packetPtr;
  640.         ultra = TRUE;
  641.         if ((ultraHdrPtr->localAddress.tsapSize == 2) &&
  642.         (ultraHdrPtr->localAddress.tsap[0] == (unsigned char) 0xff) &&
  643.         (ultraHdrPtr->localAddress.tsap[1] == (unsigned char) 0xff)) {
  644.         packetType = NET_PACKET_SPRITE;
  645.         } else {
  646.         packetType = NET_PACKET_UNKNOWN;
  647.         }
  648.         break;
  649.     }
  650.     default : 
  651.         printf("Net_Input: invalid net type %d\n", interPtr->netType);
  652.     }
  653.     headerSize = net_NetworkHeaderSize[interPtr->netType];
  654.     if (dbg_UsingNetwork) {
  655.     /*
  656.      * If the kernel debugger is running it gets all the packets. We
  657.      * process ARP requests to allow hosts to talk to the debugger.
  658.      */
  659.     if (packetType == NET_PACKET_ARP) {
  660.             NetArpInput(interPtr, packetPtr, packetLength);
  661.     } else { 
  662.         Dbg_InputPacket(interPtr, packetPtr, packetLength);
  663.     }
  664.     return;
  665.     }
  666.     switch(packetType) {
  667.         case NET_PACKET_SPRITE:
  668.         if (netDebug) {
  669.         printf("Received a Sprite packet, calling Rpc_Dispatch\n");
  670.         }
  671.             Rpc_Dispatch(interPtr, NET_PROTO_RAW, packetPtr, 
  672.              (Address) (((char *) packetPtr) + headerSize), 
  673.              packetLength - headerSize);
  674.             break;
  675.  
  676.         case NET_PACKET_ARP:
  677.     case NET_PACKET_RARP:
  678.         /*
  679.          * The kernel gets first shot at ARP packets and then they are
  680.          * forward to tbe /dev/net device.
  681.          */
  682.         if (netDebug) {
  683.         if (packetType == NET_PACKET_ARP) {
  684.             printf("Received an ARP packet.\n");
  685.         } else {
  686.             printf("Received a RARP packet.\n");
  687.         }
  688.         }
  689.             NetArpInput(interPtr, packetPtr, packetLength);
  690.         if (interPtr->packetProc != NILPROC) {
  691.         (interPtr->packetProc)(interPtr, packetLength, packetPtr);
  692.         }
  693.         break;
  694.  
  695.         case NET_PACKET_DEBUG:
  696.         if (netDebug) {
  697.         printf("Received a debug packet.\n");
  698.         }
  699.             EnterDebugger(interPtr, packetPtr, packetLength);
  700.             break;
  701.  
  702.     case NET_PACKET_IP: {
  703.         register Net_IPHeader *ipHeaderPtr = 
  704.             (Net_IPHeader *) (packetPtr + headerSize);
  705.         /*
  706.          * The kernel steals IP packets with the Sprite RPC protocol number.
  707.          */
  708.         if (netDebug) {
  709.         printf("Received an IP packet.\n");
  710.         }
  711.         if ( (packetLength > sizeof(Net_IPHeader)+headerSize) && 
  712.              (ipHeaderPtr->protocol == NET_IP_PROTOCOL_SPRITE)) {
  713.         int    headerLenInBytes;
  714.         int    totalLenInBytes;
  715.         headerLenInBytes = ipHeaderPtr->headerLen * 4;
  716.         totalLenInBytes = Net_NetToHostShort(ipHeaderPtr->totalLen);
  717.         /*
  718.          * Validate the packet. We toss out the following cases:
  719.          * 1) Runt packets.
  720.          * 2) Bad checksums.
  721.          * 3) Fragments.
  722.          * Since we sent the packets with dont fragment set we 
  723.          * shouldn't get any fragments.
  724.          */
  725.         if ((headerLenInBytes >= sizeof(Net_IPHeader)) &&
  726.              (totalLenInBytes > headerLenInBytes) &&
  727.              (totalLenInBytes <= (packetLength-headerSize)) &&
  728.              (Net_InetChecksum(headerLenInBytes, (Address)ipHeaderPtr)
  729.                                 == 0)) {
  730.  
  731.             SWAP_FRAG_OFFSET_NET_TO_HOST(ipHeaderPtr);
  732.             if((!(ipHeaderPtr->flags & NET_IP_MORE_FRAGS)) &&
  733.               (ipHeaderPtr->fragOffset == 0)) {
  734.             if (netDebug) {
  735.                 printf(
  736.             "Received a Sprite IP packet, calling Rpc_Dispatch\n");
  737.             }
  738.             Rpc_Dispatch(interPtr, NET_PROTO_INET, packetPtr, 
  739.                    (Address)(((char *) ipHeaderPtr) + headerLenInBytes),
  740.                      totalLenInBytes-headerLenInBytes);
  741.              }
  742.         }
  743.  
  744.         } else {
  745.  
  746.         if (interPtr->packetProc != NILPROC) {
  747.             (interPtr->packetProc)(interPtr, packetLength, packetPtr);
  748.         }
  749.         }
  750.         break;
  751.     }
  752.     default:
  753.         if (netDebug) {
  754.         printf("Received a packet with unknown type 0x%x.\n",
  755.             packetType);
  756.         }
  757.         if (interPtr->packetProc != NILPROC) {
  758.         (interPtr->packetProc)(interPtr, packetLength, packetPtr);
  759.         }
  760.         break;
  761.     }
  762.     return;
  763. }
  764.  
  765.  
  766. /*
  767.  *----------------------------------------------------------------------
  768.  *
  769.  * EnterDebugger --
  770.  *
  771.  *    Processes the special NET_ETHER_SPRITE_DEBUG packet type.
  772.  *    Prints the data in the packet (which is the hostname of the sender)
  773.  *    and then enters the debugger. The format of data in the packet is:
  774.  *     1) size of sender's name in bytes (4 bytes),
  775.  *     2) the sender's name (max 100 bytes).
  776.  *
  777.  * Results:
  778.  *    None.
  779.  *
  780.  * Side effects:
  781.  *    Enters the debugger.
  782.  *
  783.  *----------------------------------------------------------------------
  784.  */
  785.  
  786. /* ARGSUSED */
  787. static void
  788. EnterDebugger(interPtr, packetPtr, packetLength)
  789.     Net_Interface    *interPtr;
  790.     Address packetPtr;
  791.     int packetLength;
  792. {
  793.     char *name;
  794.     unsigned int  len;
  795.  
  796.     packetPtr += net_NetworkHeaderSize[interPtr->netType];
  797.     /*
  798.      * Copy the length out of the packet into a correctly aligned integer.
  799.      * Correct its byte order.
  800.      */
  801.     bcopy( packetPtr, (Address) &len, sizeof(len));
  802.  
  803.     len = Net_NetToHostInt(len);
  804.  
  805.     /*
  806.      * Validate the data length and make sure the name is null-terminated.
  807.      */
  808.     if (len < 100) {
  809.     name = (char *) (packetPtr + sizeof(len));
  810.     name[len] = '\0';
  811.     printf("\n*** Got a debugger packet from %s ***\n", name);
  812.     } else {
  813.     printf("\n*** Got a debugger packet ***\n");
  814.     }
  815.  
  816.     DBG_CALL;
  817.     return;
  818. }
  819.  
  820. /*
  821.  *----------------------------------------------------------------------
  822.  *
  823.  * Net_GetInterface --
  824.  *
  825.  *    Returns a pointer to the interface structure with the
  826.  *    given number and type.
  827.  *
  828.  * Results:
  829.  *    A pointer to a Net_Interface if one with the given number
  830.  *    exists, NIL otherwise.
  831.  *
  832.  * Side effects:
  833.  *    None.
  834.  *
  835.  *----------------------------------------------------------------------
  836.  */
  837.  
  838. Net_Interface *
  839. Net_GetInterface(netType, number)
  840.     Net_NetworkType    netType;    /* Type of interface. */
  841.     int            number;        /* Number of interface. */
  842. {
  843.     Net_Interface    *interPtr;
  844.     register int    i;
  845.  
  846.     interPtr = (Net_Interface *) NIL;
  847.     for (i = 0; i < netNumInterfaces; i++) {
  848.     if (netInterfaces[i]->netType == netType &&
  849.         netInterfaces[i]->number == number) {
  850.         interPtr = netInterfaces[i];
  851.         break;
  852.     }
  853.     }
  854.     return interPtr;
  855. }
  856.  
  857. /*
  858.  *----------------------------------------------------------------------
  859.  *
  860.  * Net_NextInterface --
  861.  *
  862.  *     This routine can be used to iterate through all network
  863.  *    interfaces, regardless of type.  The parameter 'index'
  864.  *    is used to keep track of where we are in the interaction.
  865.  *    A pointer will be returned to first interface whose index
  866.  *    is equal to or greater than 'index' and that is running.
  867.  *    The 'index' parameter will be set to the index of the
  868.  *    interface upon return.  
  869.  *
  870.  * Results:
  871.  *    A pointer to the first interface whose number if greater than
  872.  *    or equal to the contents of indexPtr and is running. NIL
  873.  *    if no such interface exists.
  874.  *
  875.  * Side effects:
  876.  *    None.
  877.  *
  878.  *----------------------------------------------------------------------
  879.  */
  880.  
  881. Net_Interface *
  882. Net_NextInterface(running, indexPtr)
  883.     Boolean        running;    /* TRUE => returned interface    
  884.                      * must be in running state. */
  885.     int            *indexPtr;    /* Ptr to index to use. */
  886. {
  887.     register int    i;
  888.  
  889.     for (i = *indexPtr; i < netNumInterfaces; i++) {
  890.     if (netDebug) {
  891.         printf("i = %d, name = %s, running = %d\n", i, 
  892.         netInterfaces[i]->name, 
  893.         netInterfaces[i]->flags & NET_IFLAGS_RUNNING);
  894.     }
  895.     if (!running || netInterfaces[i]->flags & NET_IFLAGS_RUNNING) {
  896.         *indexPtr = i;
  897.         return netInterfaces[i];
  898.     }
  899.     }
  900.     return (Net_Interface *) NIL;
  901. }
  902.  
  903. /*
  904.  *----------------------------------------------------------------------
  905.  *
  906.  * Net_SetPacketHandler --
  907.  *
  908.  *    Routine to register a callback for each packet received
  909.  *    on a particular network interface.
  910.  *    Right now the Net_Input routine knows about the different
  911.  *     types of packets and knows which routines to call.  This
  912.  *    routine is used to set the callback for generic packets
  913.  *    so that the dev module sees them. 
  914.  *
  915.  *    The handler parameter should have the following definition:
  916.  *        void    handler(interPtr, packetPtr, size)
  917.  *            Net_Interface    *interPtr; 
  918.  *            Address        packetPtr; 
  919.  *            int        size;       
  920.  *
  921.  *    TODO:  It would probably be nice to classify packets (rpc, ip,
  922.  *        ether, etc) and register interest in the different
  923.  *        classifications. That would make Net_Input more
  924.  *        general.
  925.  *
  926.  * Results:
  927.  *    None.
  928.  *
  929.  * Side effects:
  930.  *    The function parameter will be called for all 'normal' network
  931.  *    packets.
  932.  *
  933.  *----------------------------------------------------------------------
  934.  */
  935.  
  936. void
  937. Net_SetPacketHandler(interPtr, handler)
  938.     Net_Interface    *interPtr;    /* The interface. */
  939.     void        (*handler)();    /* Packet handling routine. */
  940. {
  941.     interPtr->packetProc = handler;
  942. }
  943.  
  944. /*
  945.  *----------------------------------------------------------------------
  946.  *
  947.  * Net_RemovePacketHandler --
  948.  *
  949.  *    Routine to remove a packet handler callback procedure.
  950.  *
  951.  * Results:
  952.  *    None.
  953.  *
  954.  * Side effects:
  955.  *    None.
  956.  *
  957.  *----------------------------------------------------------------------
  958.  */
  959.  
  960. void
  961. Net_RemovePacketHandler(interPtr)
  962.     Net_Interface    *interPtr;    /* The interface. */
  963. {
  964.     interPtr->packetProc = NILPROC;
  965. }
  966.  
  967. /*
  968.  *----------------------------------------------------------------------
  969.  *
  970.  * Net_GetStats --
  971.  *
  972.  *    Returns the event statistics for the various network 
  973.  *    interfaces.  The sum of the stats for all interfaces of the
  974.  *    given type is returned.
  975.  *
  976.  * Results:
  977.  *    SUCCESS if the statistics are returned, an error code otherwise
  978.  *
  979.  * Side effects:
  980.  *    None.
  981.  *
  982.  *----------------------------------------------------------------------
  983.  */
  984.  
  985. ReturnStatus
  986. Net_GetStats(netType, statPtr)
  987.     Net_NetworkType    netType;     /* Type of interfaces to get stats
  988.                      * for. */
  989.     Net_Stats        *statPtr;    /* Statistics to fill in. */ 
  990. {
  991.     int            i;
  992.     ReturnStatus    status = SUCCESS;
  993.     Net_Stats        tmpStats;
  994.  
  995.     bzero((char *) statPtr, sizeof(Net_Stats));
  996.     for (i = 0; i < netNumInterfaces; i++) {
  997.     if ((netInterfaces[i]->flags & NET_IFLAGS_RUNNING) &&
  998.         (netInterfaces[i]->netType == netType)) {
  999.         status = (netInterfaces[i]->getStats)(netInterfaces[i], &tmpStats);
  1000.         if (status != SUCCESS) {
  1001.         break;
  1002.         }
  1003.         NetAddStats(&tmpStats, statPtr, statPtr);
  1004.     }
  1005.     }
  1006.     return status;
  1007. }
  1008.  
  1009.  
  1010. /*
  1011.  *----------------------------------------------------------------------
  1012.  *
  1013.  * NetAddStats --
  1014.  *
  1015.  *    Add two stats structures together. This routine assumes that
  1016.  *    the structures are composed of only integers.
  1017.  *
  1018.  * Results:
  1019.  *    None.
  1020.  *
  1021.  * Side effects:
  1022.  *    None.
  1023.  *
  1024.  *----------------------------------------------------------------------
  1025.  */
  1026.  
  1027. static void
  1028. NetAddStats(aPtr, bPtr, sumPtr)
  1029.     Net_Stats *aPtr;            /* First addend. */
  1030.     Net_Stats *bPtr;            /* Second addend. */
  1031.     Net_Stats *sumPtr;            /* The sum of the two. */
  1032. {
  1033.     Net_Stats        tmp;
  1034.     int            i;
  1035.  
  1036.     bzero((char *) &tmp, sizeof(tmp));
  1037.     for (i = 0; i < sizeof(Net_Stats) / sizeof(int); i++) {
  1038.     ((int *) &tmp)[i] = ((int *) aPtr)[i] + ((int *) bPtr)[i];
  1039.     }
  1040.     bcopy((char *) &tmp, (char *) sumPtr, sizeof(Net_Stats));
  1041. }
  1042.  
  1043.